import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../common/services/index.dart';
import '../../../common/mixins/index.dart';
import '../../../common/models/index.dart';
import '../../../common/api/index.dart'; // 添加API导入
import '../../../common/routers/index.dart';
import '../../../common/utils/index.dart';
import '../../system/main/controller.dart';

/// 我的页面控制器
/// 负责用户个人信息展示和相关操作
/// 遵循GetX控制器标准化结构（9个部分）
/// 使用UserProfileMixin提供用户信息访问能力
class MyIndexController extends GetxController with UserProfileMixin {
  // 1. 静态常量（类级别）- 使用lowerCamelCase命名
  static const String tag = 'MyIndexController';
  static const int maxRetryCount = 3;
  static const Duration refreshTimeout = Duration(seconds: 30);
  static const Duration logoutTimeout = Duration(seconds: 10);
  
  // 2. 实例常量
  final String pageTitle = '我的';
  final String welcomeMessage = '欢迎使用';
  final String appVersion = '1.0.0';
  
  // 3. 响应式变量（Rx系列）- 使用.obs写法（推荐95%场景）
  // 基础类型响应式变量
  var isLoading = false.obs;                    // RxBool - 加载状态
  var isRefreshing = false.obs;                 // RxBool - 刷新状态
  var hasError = false.obs;                     // RxBool - 错误状态
  var retryCount = 0.obs;                       // RxInt - 重试次数
  var errorMessage = ''.obs;                    // RxString - 错误信息
  
  // 集合类型响应式变量
  var settingsMenu = <MenuItem>[].obs;          // RxList<MenuItem> - 设置菜单项
  
  // 注意：头像相关状态由 UserService 统一管理，无需在此重复定义
  
  // 可空类型响应式变量（特殊场景使用）
  var lastRefreshTime = RxnString();            // RxnString - 上次刷新时间（可空）
  
  // 我的页面数据（响应式）
  var myHeadInfo = Rxn<ApiUserInfoMyHead>();    // RxnApiUserInfoMyHead - 我的页面头部信息
  
  // AppBar相关响应式变量
  var appBarOpacity = 0.0.obs;                  // RxDouble - AppBar透明度 (0-1)
  var showAppBarTitle = false.obs;              // RxBool - 是否显示AppBar标题
  
  // Tab相关响应式变量
  var currentTabIndex = 0.obs;                  // RxInt - 当前Tab索引 (0-喜欢, 1-推荐, 2-历史, 3-收藏)
  
  // 短视频列表数据（4个Tab分别维护）
  var likesVideos = <ApiShortVideoDto>[].obs;   // RxList - 喜欢的视频列表
  var recommendVideos = <ApiShortVideoDto>[].obs; // RxList - 推荐视频列表
  var historyVideos = <ApiShortVideoDto>[].obs;  // RxList - 历史视频列表
  var collectionVideos = <ApiShortVideoDto>[].obs; // RxList - 收藏视频列表
  
  // 加载状态
  var likesLoading = false.obs;                 // RxBool - 喜欢列表加载状态
  var recommendLoading = false.obs;             // RxBool - 推荐列表加载状态
  var historyLoading = false.obs;               // RxBool - 历史列表加载状态
  var collectionLoading = false.obs;            // RxBool - 收藏列表加载状态
  
  // 分页信息（从0开始，对标Android实现）
  var likesPage = 0.obs;                        // RxInt - 喜欢列表当前页
  var recommendPage = 0.obs;                    // RxInt - 推荐列表当前页
  var historyPage = 0.obs;                      // RxInt - 历史列表当前页
  var collectionPage = 0.obs;                   // RxInt - 收藏列表当前页
  
  var likesHasMore = true.obs;                  // RxBool - 喜欢列表是否有更多
  var recommendHasMore = true.obs;              // RxBool - 推荐列表是否有更多
  var historyHasMore = true.obs;                // RxBool - 历史列表是否有更多
  var collectionHasMore = true.obs;             // RxBool - 收藏列表是否有更多
  
  // 4. 普通变量（非响应式）
  bool _isInitialized = false;
  int _internalRetryCount = 0;
  
  // 滚动控制器
  late ScrollController scrollController;
  
  // 5. 控制器和服务依赖
  // 服务依赖
  UserService get _userService => Get.find<UserService>();
  
  // 6. 构造函数
  MyIndexController() {
    debugPrint('$tag: Constructor - 控制器已创建 ${DateTime.now()}');
  }
  
  // 7. 私有初始化方法
  void _initData() {
    debugPrint('$tag: 初始化我的页面数据');
    
    if (!_isInitialized) {
      // 初始化设置菜单
      _initSettingsMenu();
      
    // 检查用户登录状态（静默加载，不显示错误）
    _checkUserLoginStatus();
      
      // 设置UserService响应式数据监听
      _setupUserServiceListeners();
      
      // 设置已初始化标志
      _isInitialized = true;
      
      debugPrint('$tag: 页面数据初始化完成');
    }
    
    // 通知UI更新
    update(["my_index"]);
  }
  
  /// 初始化设置菜单
  void _initSettingsMenu() {
    settingsMenu.assignAll([
      MenuItem(
        icon: Icons.settings_outlined,
        title: '设置',
        subtitle: '个人设置和偏好',
      ),
      MenuItem(
        icon: Icons.info_outline,
        title: '关于我们',
        subtitle: '应用信息和版本',
      ),
    ]);
    debugPrint('$tag: 设置菜单初始化完成');
  }
  
  /// 检查用户登录状态
  void _checkUserLoginStatus() {
    final isLoggedIn = _userService.isLoggedIn;
    debugPrint('$tag: 用户登录状态检查 - isLoggedIn: $isLoggedIn');
    
    if (!isLoggedIn) {
      debugPrint('$tag: 用户未登录，清理本地状态');
      _clearLocalState();
    } else {
      debugPrint('$tag: 用户已登录，静默加载我的页面数据（不显示错误提示）');
      loadMyHeadInfo(showError: false); // 初始化时静默加载
    }
  }
  
  /// 清理本地状态
  void _clearLocalState() {
    hasError.value = false;
    errorMessage.value = '';
    retryCount.value = 0;
    lastRefreshTime.value = null;
  }
  
  /// 设置UserService响应式数据监听
  /// 当UserService中的用户信息发生变化时，自动更新UI
  void _setupUserServiceListeners() {
    debugPrint('$tag: 设置UserService响应式数据监听');
    
    // 监听UserProfileModel变化 - 这是核心响应式数据
    ever(_userService.currentUserProfileRx, (userProfile) {
      debugPrint('$tag: UserService用户信息模型发生变化，自动更新UI');
      debugPrint('$tag: 新用户信息: ${userProfile?.nickName ?? "无"}');
      update(["my_index"]);
    });
    
    // 监听登录状态变化
    ever(_userService.isLoggedInRx, (isLoggedIn) {
      debugPrint('$tag: UserService登录状态发生变化: $isLoggedIn，更新UI');
      
      if (isLoggedIn) {
        // ✅ 登录成功，立即加载我的页面数据（静默加载）
        loadMyHeadInfo(showError: false);
      } else {
        // 退出登录，清空数据
        myHeadInfo.value = null;
      }
      
      update(["my_index"]);
    });
    
    debugPrint('$tag: ✅ 响应式监听器设置完成 - 用户信息变化将自动同步到UI');
  }
  
  // 8. 业务方法
  
  // ==================== 用户信息访问 ====================
  // 注意：用户信息访问方法已通过 UserProfileMixin 提供
  // 可直接使用: userDisplayName, userName, userAvatarUrl, isLoggedIn 等
  
  // ==================== 我的页面数据加载 ====================
  
  /// 加载我的页面头部信息
  /// 
  /// [showError] 是否显示错误提示，默认false（静默失败）
  /// - true: 显示错误提示（用户主动刷新时）
  /// - false: 静默失败（页面初始化时）
  Future<void> loadMyHeadInfo({bool showError = false}) async {
    try {
      isLoading.value = true;
      hasError.value = false;
      update(["my_index"]);
      
      debugPrint('$tag: 开始加载我的页面头部信息');
      
      // 调用 Mixin 提供的方法（通过 UserService）
      final headInfo = await getMyHeadInfo();
      myHeadInfo.value = headInfo;
      
      debugPrint('$tag: 我的页面数据加载完成');
      debugPrint('$tag: 📊 统计数据:');
      debugPrint('$tag:   - 粉丝: ${headInfo.fansNum}');
      debugPrint('$tag:   - 关注: ${headInfo.followNum}');
      debugPrint('$tag:   - 互关: ${headInfo.mutualFollowNum}');
      debugPrint('$tag:   - 打赏: ${headInfo.giveMeRewardNum}');
      
    } catch (e) {
      debugPrint('$tag: 加载我的页面数据失败: $e');
      
      // 检查是否是token失效
      final errorMsg = e.toString().toLowerCase();
      final isTokenError = errorMsg.contains('token') || 
                          errorMsg.contains('登录') || 
                          errorMsg.contains('认证');
      
      if (isTokenError) {
        debugPrint('$tag: ⚠️ Token失效，静默处理（不显示错误提示）');
        // token失效时，仅记录错误状态，不显示提示
        hasError.value = true;
        errorMessage.value = 'token失效';
      } else if (showError) {
        // 非token错误且允许显示提示时，才显示错误
        _handleError('获取个人信息失败，请稍后重试');
      } else {
        debugPrint('$tag: 静默处理错误，不显示提示');
        hasError.value = true;
        errorMessage.value = e.toString();
      }
    } finally {
      isLoading.value = false;
      update(["my_index"]);
    }
  }
  
  // ==================== 刷新相关方法 ====================
  
  /// 刷新用户信息（用户主动操作）
  Future<void> refreshUserInfo() async {
    try {
      isRefreshing.value = true;
      hasError.value = false;
      errorMessage.value = '';
      update(["my_index"]);
      
      debugPrint('$tag: 开始刷新用户信息（用户主动操作）');
      
      // 重置重试计数
      _internalRetryCount = 0;
      
      // 重新加载我的页面数据（显示错误提示）
      await loadMyHeadInfo(showError: true);
      
      // 更新最后刷新时间
      lastRefreshTime.value = DateTime.now().toString();
      
      debugPrint('$tag: 用户信息刷新完成');
      _showSuccessMessage('用户信息已刷新');
      
    } catch (e) {
      debugPrint('$tag: 刷新用户信息失败: $e');
      _handleRefreshError('获取用户信息失败，请稍后重试');
    } finally {
      isRefreshing.value = false;
      update(["my_index"]);
    }
  }
  
  /// 处理刷新错误
  void _handleRefreshError(String message) {
    retryCount.value++;
    _internalRetryCount++;
    
    if (_internalRetryCount < maxRetryCount) {
      debugPrint('$tag: 刷新失败，准备重试 (${_internalRetryCount}/$maxRetryCount)');
      // 延迟重试
      Future.delayed(const Duration(seconds: 2), () {
        if (_internalRetryCount < maxRetryCount) {
          refreshUserInfo();
        }
      });
    } else {
      _handleError(message);
    }
  }
  
  // ==================== 退出登录相关方法 ====================
  
  /// 退出登录
  void onLogoutTap() async {
    try {
      debugPrint('$tag: 用户点击退出登录');
      
      // 显示确认对话框
      final result = await _showLogoutConfirmDialog();
      
      // 用户确认退出
      if (result == true) {
        await _performLogout();
      } else {
        debugPrint('$tag: 用户取消退出登录');
      }
      
    } catch (e) {
      debugPrint('$tag: 退出登录异常: $e');
      _showErrorMessage('退出登录时发生错误，请重试');
    }
  }
  
  /// 显示退出确认对话框
  Future<bool?> _showLogoutConfirmDialog() async {
    return await Get.dialog<bool>(
      AlertDialog(
        title: const Text('确认退出'),
        content: const Text('您确定要退出登录吗？'),
        actions: [
          TextButton(
            onPressed: () => Get.back(result: false),
            child: const Text('取消'),
          ),
          TextButton(
            onPressed: () => Get.back(result: true),
            child: const Text(
              '退出',
              style: TextStyle(color: Colors.red),
            ),
          ),
        ],
      ),
    );
  }
  
  /// 执行退出登录
  Future<void> _performLogout() async {
    try {
      isLoading.value = true;
      hasError.value = false;
      update(["my_index"]);
      
      debugPrint('$tag: 开始执行退出登录流程');
      
      // 调用用户服务退出登录（带超时控制）
      final success = await _userService.logout().timeout(
        logoutTimeout,
        onTimeout: () {
          debugPrint('$tag: 退出登录超时');
          return false;
        },
      );
      
      if (success) {
        debugPrint('$tag: 退出登录成功');
        
        // 清理本地状态
        _clearLocalState();
        
        // 显示成功提示
        _showSuccessMessage('已成功退出登录');
        
        // 短暂延迟让用户看到成功提示，然后直接重置到首页
        await Future.delayed(const Duration(milliseconds: 500));
        
        // 直接重置MainController到首页状态，无需路由跳转
        _resetMainControllerToHome();
        
      } else {
        debugPrint('$tag: 退出登录失败');
        _handleError('退出登录失败，请重试');
      }
      
    } catch (e) {
      debugPrint('$tag: 执行退出登录异常: $e');
      _handleError('退出登录时发生错误');  
    } finally {
      isLoading.value = false;
      update(["my_index"]);
    }
  }
  
  // ==================== 头像相关方法 ====================
  
  /// 头像点击 - 跳转到个人信息编辑页面
  void onAvatarTap() {
    debugPrint('$tag: 用户点击头像');
    
    if (!isLoggedIn) {
      _showErrorMessage('请先登录');
      return;
    }
    
    // 跳转到个人信息编辑页面
    Get.toNamed(RouteNames.myPeofileDetial);
    debugPrint('$tag: 跳转到个人信息编辑页面');
  }
  
  // ==================== 设置和功能相关方法 ====================
  
  /// 用户设置点击
  void onSettingsTap() {
    debugPrint('$tag: 用户点击设置');
    
    // 跳转到设置页面
    Get.toNamed(RouteNames.mySettings);
    debugPrint('$tag: 跳转到设置页面');
  }
  
  /// 编辑用户信息点击
  void onEditProfileTap() {
    debugPrint('$tag: 用户点击编辑信息');
    
    if (!isLoggedIn) {
      _showErrorMessage('请先登录');
      return;
    }
    
    // 跳转到个人信息编辑页面
    Get.toNamed(RouteNames.myPeofileDetial);
    debugPrint('$tag: 跳转到个人信息编辑页面');
  }

  /// 昵称点击 - 编辑用户信息
  void onUserNameTap() {
    debugPrint('$tag: 用户点击昵称');
    
    if (!isLoggedIn) {
      _showErrorMessage('请先登录');
      return;
    }
    
    // 跳转到个人信息编辑页面
    Get.toNamed(RouteNames.myPeofileDetial);
    debugPrint('$tag: 通过昵称点击跳转到个人信息编辑页面');
  }
  
  /// 关于我们点击
  void onAboutTap() {
    debugPrint('$tag: 用户点击关于我们');
    
    Get.dialog(
      AlertDialog(
        title: const Text('关于我们'),
        content: Text('$welcomeMessage\n版本: $appVersion\n© 2025 All Rights Reserved'),
        actions: [
          TextButton(
            onPressed: () => Get.back(),
            child: const Text('确定'),
          ),
        ],
      ),
    );
  }
  
  // ==================== 消息提示相关方法 ====================
  
  /// 显示成功消息
  void _showSuccessMessage(String message) {
    LoadingUtil.success(message);
  }
  
  /// 显示错误消息
  void _showErrorMessage(String message) {
    LoadingUtil.error(message, duration: const Duration(seconds: 3));
  }
  
  /// 显示信息消息
  void _showInfoMessage(String message) {
    LoadingUtil.info(message);
  }
  
  // ==================== 主页面状态重置相关方法 ====================
  
  /// 直接重置MainController到首页状态
  /// 最简洁高效的退出登录解决方案 - 无需路由跳转
  void _resetMainControllerToHome() {
    debugPrint('$tag: 🚀 启动退出登录状态重置');
    
    try {
      // 调用MainController的专用重置方法
      final mainController = Get.find<MainController>();
      mainController.resetToHomeAfterLogout();
      
      debugPrint('$tag: ✅ 退出登录完成，用户已回到首页');
      
    } catch (e) {
      debugPrint('$tag: ❌ 重置失败: $e');
      _showErrorMessage('页面切换异常，请重新打开应用');
    }
  }

  // ==================== 错误处理相关方法 ====================
  
  /// 处理错误
  void _handleError(String message) {
    hasError.value = true;
    errorMessage.value = message;
    
    debugPrint('$tag: 处理错误 - $message');
    _showErrorMessage(message);
    
    update(["my_index"]);
  }
  
  /// 重置错误状态
  void resetErrorState() {
    debugPrint('$tag: 重置错误状态');
    
    hasError.value = false;
    errorMessage.value = '';
    retryCount.value = 0;
    _internalRetryCount = 0;
    
    update(["my_index"]);
  }

  // ==================== AppBar滚动相关方法 ====================
  
  /// 初始化滚动控制器
  void _initScrollController() {
    scrollController = ScrollController();
    scrollController.addListener(_onScroll);
    debugPrint('$tag: 滚动控制器已初始化并添加监听');
  }
  
  /// 滚动监听回调
  void _onScroll() {
    // 获取滚动位置
    final offset = scrollController.offset;
    final maxScroll = scrollController.position.maxScrollExtent;
    
    // AppBar高度阈值（滚动超过这个值时显示白色AppBar）
    const threshold = 180.0; // 用户头像卡片大约的高度
    
    // 计算透明度（0-1之间）
    double opacity = (offset / threshold).clamp(0.0, 1.0);
    
    // 更新AppBar透明度
    if (appBarOpacity.value != opacity) {
      appBarOpacity.value = opacity;
    }
    
    // 更新是否显示标题（滚动超过一半时显示）
    bool shouldShowTitle = offset > (threshold * 0.5);
    if (showAppBarTitle.value != shouldShowTitle) {
      showAppBarTitle.value = shouldShowTitle;
    }
    
    // 滚动到底部时自动加载更多（距离底部200px时触发）
    if (maxScroll - offset < 200) {
      _loadMoreOnScroll();
    }
  }
  
  /// 滚动到底部时加载更多
  void _loadMoreOnScroll() {
    switch (currentTabIndex.value) {
      case 0:
        if (!likesLoading.value && likesHasMore.value) {
          loadLikesVideos();
        }
        break;
      case 1:
        if (!recommendLoading.value && recommendHasMore.value) {
          loadRecommendVideos();
        }
        break;
      case 2:
        if (!historyLoading.value && historyHasMore.value) {
          loadHistoryVideos();
        }
        break;
      case 3:
        if (!collectionLoading.value && collectionHasMore.value) {
          loadCollectionVideos();
        }
        break;
    }
  }
  
  // ==================== Tab切换相关方法 ====================
  
  /// 切换Tab
  void onTabTap(int index) {
    debugPrint('$tag: 切换到Tab $index');
    currentTabIndex.value = index;
    
    // 根据不同Tab加载对应的短视频列表
    switch (index) {
      case 0:
        debugPrint('$tag: 显示喜欢列表');
        if (likesVideos.isEmpty && !likesLoading.value) {
          loadLikesVideos();
        }
        break;
      case 1:
        debugPrint('$tag: 显示推荐内容');
        if (recommendVideos.isEmpty && !recommendLoading.value) {
          loadRecommendVideos();
        }
        break;
      case 2:
        debugPrint('$tag: 显示历史记录');
        if (historyVideos.isEmpty && !historyLoading.value) {
          loadHistoryVideos();
        }
        break;
      case 3:
        debugPrint('$tag: 显示收藏内容');
        if (collectionVideos.isEmpty && !collectionLoading.value) {
          loadCollectionVideos();
        }
        break;
    }
  }
  
  // ==================== 短视频数据加载相关方法 ====================
  
  /// 加载喜欢的视频列表
  /// type=2 (我喜欢的)
  Future<void> loadLikesVideos({bool refresh = false}) async {
    if (!isLoggedIn) {
      debugPrint('$tag: 用户未登录，无法加载喜欢列表');
      return;
    }
    
    if (likesLoading.value) {
      debugPrint('$tag: 喜欢列表正在加载中，忽略重复请求');
      return;
    }
    
    try {
      if (refresh) {
        likesPage.value = 0;
        likesHasMore.value = true;
      }
      
      if (!likesHasMore.value && !refresh) {
        debugPrint('$tag: 喜欢列表已无更多数据');
        return;
      }
      
      likesLoading.value = true;
      debugPrint('$tag: 开始加载喜欢列表 - 页码: ${likesPage.value}');
      
      final result = await ShortVideoApi.getUserShortVideoPage(
        page: likesPage.value,
        pageSize: 20,
        toUid: -1,  // -1查询自己
        type: 2,    // 2:我喜欢的
      );
      
      if (refresh) {
        likesVideos.value = result.videos;
      } else {
        likesVideos.addAll(result.videos);
      }
      
      likesHasMore.value = result.hasMore;
      if (result.hasMore) {
        likesPage.value++;
      }
      
      debugPrint('$tag: 喜欢列表加载完成 - 共${likesVideos.length}条');
      
    } catch (e) {
      debugPrint('$tag: 加载喜欢列表失败: $e');
      _showErrorMessage('加载失败，请稍后重试');
    } finally {
      likesLoading.value = false;
    }
  }
  
  /// 加载推荐视频列表
  /// type=0 (推荐)
  Future<void> loadRecommendVideos({bool refresh = false}) async {
    if (!isLoggedIn) {
      debugPrint('$tag: 用户未登录，无法加载推荐列表');
      return;
    }
    
    if (recommendLoading.value) {
      debugPrint('$tag: 推荐列表正在加载中，忽略重复请求');
      return;
    }
    
    try {
      if (refresh) {
        recommendPage.value = 0;
        recommendHasMore.value = true;
      }
      
      if (!recommendHasMore.value && !refresh) {
        debugPrint('$tag: 推荐列表已无更多数据');
        return;
      }
      
      recommendLoading.value = true;
      debugPrint('$tag: 开始加载推荐列表 - 页码: ${recommendPage.value}');
      
      final result = await ShortVideoApi.getUserShortVideoPage(
        page: recommendPage.value,
        pageSize: 20,
        toUid: -1,
        type: 0,    // 0:推荐
      );
      
      if (refresh) {
        recommendVideos.value = result.videos;
      } else {
        recommendVideos.addAll(result.videos);
      }
      
      recommendHasMore.value = result.hasMore;
      if (result.hasMore) {
        recommendPage.value++;
      }
      
      debugPrint('$tag: 推荐列表加载完成 - 共${recommendVideos.length}条');
      
    } catch (e) {
      debugPrint('$tag: 加载推荐列表失败: $e');
      _showErrorMessage('加载失败，请稍后重试');
    } finally {
      recommendLoading.value = false;
    }
  }
  
  /// 加载历史记录列表
  /// type=4 (历史)
  Future<void> loadHistoryVideos({bool refresh = false}) async {
    if (!isLoggedIn) {
      debugPrint('$tag: 用户未登录，无法加载历史记录');
      return;
    }
    
    if (historyLoading.value) {
      debugPrint('$tag: 历史记录正在加载中，忽略重复请求');
      return;
    }
    
    try {
      if (refresh) {
        historyPage.value = 0;
        historyHasMore.value = true;
      }
      
      if (!historyHasMore.value && !refresh) {
        debugPrint('$tag: 历史记录已无更多数据');
        return;
      }
      
      historyLoading.value = true;
      debugPrint('$tag: 开始加载历史记录 - 页码: ${historyPage.value}');
      
      final result = await ShortVideoApi.getUserShortVideoPage(
        page: historyPage.value,
        pageSize: 20,
        toUid: -1,
        type: 4,    // 4:历史
      );
      
      if (refresh) {
        historyVideos.value = result.videos;
      } else {
        historyVideos.addAll(result.videos);
      }
      
      historyHasMore.value = result.hasMore;
      if (result.hasMore) {
        historyPage.value++;
      }
      
      debugPrint('$tag: 历史记录加载完成 - 共${historyVideos.length}条');
      
    } catch (e) {
      debugPrint('$tag: 加载历史记录失败: $e');
      _showErrorMessage('加载失败，请稍后重试');
    } finally {
      historyLoading.value = false;
    }
  }
  
  /// 加载收藏视频列表
  /// type=2 (收藏，使用喜欢类型)
  Future<void> loadCollectionVideos({bool refresh = false}) async {
    if (!isLoggedIn) {
      debugPrint('$tag: 用户未登录，无法加载收藏列表');
      return;
    }
    
    if (collectionLoading.value) {
      debugPrint('$tag: 收藏列表正在加载中，忽略重复请求');
      return;
    }
    
    try {
      if (refresh) {
        collectionPage.value = 0;
        collectionHasMore.value = true;
      }
      
      if (!collectionHasMore.value && !refresh) {
        debugPrint('$tag: 收藏列表已无更多数据');
        return;
      }
      
      collectionLoading.value = true;
      debugPrint('$tag: 开始加载收藏列表 - 页码: ${collectionPage.value}');
      
      final result = await ShortVideoApi.getUserShortVideoPage(
        page: collectionPage.value,
        pageSize: 20,
        toUid: -1,
        type: 2,    // 2:收藏(使用喜欢类型)
      );
      
      if (refresh) {
        collectionVideos.value = result.videos;
      } else {
        collectionVideos.addAll(result.videos);
      }
      
      collectionHasMore.value = result.hasMore;
      if (result.hasMore) {
        collectionPage.value++;
      }
      
      debugPrint('$tag: 收藏列表加载完成 - 共${collectionVideos.length}条');
      
    } catch (e) {
      debugPrint('$tag: 加载收藏列表失败: $e');
      _showErrorMessage('加载失败，请稍后重试');
    } finally {
      collectionLoading.value = false;
    }
  }
  
  /// 视频点赞/取消点赞
  Future<void> toggleVideoLike(ApiShortVideoDto video, int tabIndex) async {
    try {
      debugPrint('$tag: 点赞视频 - ID: ${video.shortVideoId}');
      
      // 调用API
      await ShortVideoApi.shortVideoZan(video.shortVideoId);
      
      // 更新本地数据
      final newLikeStatus = !video.liked;
      final updatedVideo = video.copyWithLike(newLikeStatus);
      
      // 根据Tab更新对应列表
      switch (tabIndex) {
        case 0:
          final index = likesVideos.indexWhere((v) => v.shortVideoId == video.shortVideoId);
          if (index != -1) {
            likesVideos[index] = updatedVideo;
          }
          break;
        case 1:
          final index = recommendVideos.indexWhere((v) => v.shortVideoId == video.shortVideoId);
          if (index != -1) {
            recommendVideos[index] = updatedVideo;
          }
          break;
        case 2:
          final index = historyVideos.indexWhere((v) => v.shortVideoId == video.shortVideoId);
          if (index != -1) {
            historyVideos[index] = updatedVideo;
          }
          break;
        case 3:
          final index = collectionVideos.indexWhere((v) => v.shortVideoId == video.shortVideoId);
          if (index != -1) {
            collectionVideos[index] = updatedVideo;
          }
          break;
      }
      
      debugPrint('$tag: 点赞状态更新成功');
      
    } catch (e) {
      debugPrint('$tag: 点赞操作失败: $e');
      _showErrorMessage('操作失败，请稍后重试');
    }
  }

  // 9. 生命周期方法
  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: onInit - 控制器初始化');
    
    // 初始化滚动控制器
    _initScrollController();
  }

  @override
  void onReady() {
    super.onReady();
    debugPrint('$tag: onReady - 页面准备就绪');
    _initData();
  }

  @override
  void onClose() {
    debugPrint('$tag: onClose - 控制器销毁');
    
    // 清理资源
    scrollController.removeListener(_onScroll);
    scrollController.dispose();
    _clearLocalState();
    
    super.onClose();
  }
}

/// 菜单项模型
class MenuItem {
  final IconData icon;
  final String title;
  final String subtitle;

  const MenuItem({
    required this.icon,
    required this.title,
    required this.subtitle,
  });
}

